{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import os\n",
    "from glob import glob\n",
    "import shutil\n",
    "import sys\n",
    "import json\n",
    "import time\n",
    "import datetime\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt \n",
    "from PIL import Image\n",
    "%matplotlib inline\n",
    "# sys.path.append(’引用模块的地址') \n",
    "# 这两行代码解决 plt 中文显示的问题\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "#设定随机种子\n",
    "np.random.seed(0)\n",
    "# img_path\n",
    "def plt_img(img):\n",
    "    cv2.imwrite(\"out.jpg\", img)\n",
    "    img = Image.open(\"out.jpg\")\n",
    "    img = np.array(img)\n",
    "    plt.imshow(img)\n",
    "  #  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-3-99fd9769622b>:17: DeprecationWarning: an integer is required (got type numpy.float32).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  cv2.rectangle(img, (gt[0], gt[1]), (gt[2], gt[3]), (0,255,255), 1)\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "# read image\n",
    "path = r\"D:\\work space\\git\\ImageProcessing100Wen\\Question_91_100\"\n",
    "img_path = os.path.join(path, 'imori_1.jpg')\n",
    "img = cv2.imread(img_path)\n",
    "H, W, C = img.shape\n",
    "\n",
    "# Grayscale\n",
    "gray = 0.2126 * img[..., 2] + 0.7152 * img[..., 1] + 0.0722 * img[..., 0]\n",
    "\n",
    "gt = np.array((47, 41, 129, 103), dtype=np.float32)\n",
    "\n",
    "cv2.rectangle(img, (gt[0], gt[1]), (gt[2], gt[3]), (0,255,255), 1)\n",
    "\n",
    "def iou(a, b):\n",
    "    area_a = (a[2] - a[0]) * (a[3] - a[1])\n",
    "    area_b = (b[2] - b[0]) * (b[3] - b[1])\n",
    "    iou_x1 = np.maximum(a[0], b[0])\n",
    "    iou_y1 = np.maximum(a[1], b[1])\n",
    "    iou_x2 = np.minimum(a[2], b[2])\n",
    "    iou_y2 = np.minimum(a[3], b[3])\n",
    "    iou_w = max(iou_x2 - iou_x1, 0)\n",
    "    iou_h = max(iou_y2 - iou_y1, 0)\n",
    "    area_iou = iou_w * iou_h\n",
    "    iou = area_iou / (area_a + area_b - area_iou)\n",
    "    return iou\n",
    "\n",
    "\n",
    "def hog(gray):\n",
    "    h, w = gray.shape\n",
    "    # Magnitude and gradient\n",
    "    gray = np.pad(gray, (1, 1), 'edge')\n",
    "\n",
    "    gx = gray[1:h+1, 2:] - gray[1:h+1, :w]\n",
    "    gy = gray[2:, 1:w+1] - gray[:h, 1:w+1]\n",
    "    gx[gx == 0] = 0.000001\n",
    "\n",
    "    mag = np.sqrt(gx ** 2 + gy ** 2)\n",
    "    gra = np.arctan(gy / gx)\n",
    "    gra[gra<0] = np.pi / 2 + gra[gra < 0] + np.pi / 2\n",
    "\n",
    "    # Gradient histogram\n",
    "    gra_n = np.zeros_like(gra, dtype=np.int)\n",
    "\n",
    "    d = np.pi / 9\n",
    "    for i in range(9):\n",
    "        gra_n[np.where((gra >= d * i) & (gra <= d * (i+1)))] = i\n",
    "\n",
    "    N = 8\n",
    "    HH = h // N\n",
    "    HW = w // N\n",
    "    Hist = np.zeros((HH, HW, 9), dtype=np.float32)\n",
    "    for y in range(HH):\n",
    "        for x in range(HW):\n",
    "            for j in range(N):\n",
    "                for i in range(N):\n",
    "                    Hist[y, x, gra_n[y*4+j, x*4+i]] += mag[y*4+j, x*4+i]\n",
    "                \n",
    "    ## Normalization\n",
    "    C = 3\n",
    "    eps = 1\n",
    "    for y in range(HH):\n",
    "        for x in range(HW):\n",
    "            #for i in range(9):\n",
    "            Hist[y, x] /= np.sqrt(np.sum(Hist[max(y-1,0):min(y+2, HH), max(x-1,0):min(x+2, HW)] ** 2) + eps)\n",
    "\n",
    "    return Hist\n",
    "\n",
    "def resize(img, h, w):\n",
    "    _h, _w  = img.shape\n",
    "    ah = 1. * h / _h\n",
    "    aw = 1. * w / _w\n",
    "    y = np.arange(h).repeat(w).reshape(w, -1)\n",
    "    x = np.tile(np.arange(w), (h, 1))\n",
    "    y = (y / ah)\n",
    "    x = (x / aw)\n",
    "\n",
    "    ix = np.floor(x).astype(np.int32)\n",
    "    iy = np.floor(y).astype(np.int32)\n",
    "    ix = np.minimum(ix, _w-2)\n",
    "    iy = np.minimum(iy, _h-2)\n",
    "\n",
    "    dx = x - ix\n",
    "    dy = y - iy\n",
    "    \n",
    "    out = (1-dx) * (1-dy) * img[iy, ix] + dx * (1 - dy) * img[iy, ix+1] + (1 - dx) * dy * img[iy+1, ix] + dx * dy * img[iy+1, ix+1]\n",
    "    out[out>255] = 255\n",
    "\n",
    "    return out\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# crop and create database\n",
    "\n",
    "Crop_num = 200\n",
    "L = 60\n",
    "H_size = 32\n",
    "F_n = ((H_size // 8) ** 2) * 9\n",
    "\n",
    "db = np.zeros((Crop_num, F_n+1))\n",
    "\n",
    "for i in range(Crop_num):\n",
    "    x1 = np.random.randint(W-L)\n",
    "    y1 = np.random.randint(H-L)\n",
    "    x2 = x1 + L\n",
    "    y2 = y1 + L\n",
    "    crop = np.array((x1, y1, x2, y2))\n",
    "\n",
    "    _iou = iou(gt, crop)\n",
    "\n",
    "    if _iou >= 0.5:\n",
    "        cv2.rectangle(img, (x1, y1), (x2, y2), (0,0,255), 1)\n",
    "        label = 1\n",
    "    else:\n",
    "        cv2.rectangle(img, (x1, y1), (x2, y2), (255,0,0), 1)\n",
    "        label = 0\n",
    "\n",
    "    crop_area = gray[y1:y2, x1:x2]\n",
    "    crop_area = resize(crop_area, H_size, H_size)\n",
    "    _hog = hog(crop_area)\n",
    "    \n",
    "    db[i, :F_n] = _hog.ravel()\n",
    "    db[i, -1] = label\n",
    "\n",
    "\n",
    "class NN:\n",
    "    def __init__(self, ind=2, w=64, w2=64, outd=1, lr=0.1):\n",
    "        self.w1 = np.random.normal(0, 1, [ind, w])\n",
    "        self.b1 = np.random.normal(0, 1, [w])\n",
    "        self.w2 = np.random.normal(0, 1, [w, w2])\n",
    "        self.b2 = np.random.normal(0, 1, [w2])\n",
    "        self.wout = np.random.normal(0, 1, [w2, outd])\n",
    "        self.bout = np.random.normal(0, 1, [outd])\n",
    "        self.lr = lr\n",
    "\n",
    "    def forward(self, x):\n",
    "        self.z1 = x\n",
    "        self.z2 = sigmoid(np.dot(self.z1, self.w1) + self.b1)\n",
    "        self.z3 = sigmoid(np.dot(self.z2, self.w2) + self.b2)\n",
    "        self.out = sigmoid(np.dot(self.z3, self.wout) + self.bout)\n",
    "        return self.out\n",
    "\n",
    "    def train(self, x, t):\n",
    "        # backpropagation output layer\n",
    "        #En = t * np.log(self.out) + (1-t) * np.log(1-self.out)\n",
    "        En = (self.out - t) * self.out * (1 - self.out)\n",
    "        grad_wout = np.dot(self.z3.T, En)\n",
    "        grad_bout = np.dot(np.ones([En.shape[0]]), En)\n",
    "        self.wout -= self.lr * grad_wout\n",
    "        self.bout -= self.lr * grad_bout\n",
    "\n",
    "        # backpropagation inter layer\n",
    "        grad_u2 = np.dot(En, self.wout.T) * self.z3 * (1 - self.z3)\n",
    "        grad_w2 = np.dot(self.z2.T, grad_u2)\n",
    "        grad_b2 = np.dot(np.ones([grad_u2.shape[0]]), grad_u2)\n",
    "        self.w2 -= self.lr * grad_w2\n",
    "        self.b2 -= self.lr * grad_b2\n",
    "        \n",
    "        grad_u1 = np.dot(grad_u2, self.w2.T) * self.z2 * (1 - self.z2)\n",
    "        grad_w1 = np.dot(self.z1.T, grad_u1)\n",
    "        grad_b1 = np.dot(np.ones([grad_u1.shape[0]]), grad_u1)\n",
    "        self.w1 -= self.lr * grad_w1\n",
    "        self.b1 -= self.lr * grad_b1\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1. / (1. + np.exp(-x))\n",
    "    \n",
    "\n",
    "## training neural network\n",
    "nn = NN(ind=F_n, lr=0.01)\n",
    "for i in range(10000):\n",
    "    nn.forward(db[:, :F_n])\n",
    "    nn.train(db[:, :F_n], db[:, -1][..., None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-16-4bc3d1960da7>:31: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n",
      "  detects = np.vstack((detects, np.array((x1, y1, x2, y2, score))))\n"
     ]
    }
   ],
   "source": [
    "# read detect target image\n",
    "img_path = os.path.join(path, 'imori_many.jpg')\n",
    "img2 = cv2.imread(img_path)\n",
    "H2, W2, C2 = img2.shape\n",
    "\n",
    "# Grayscale\n",
    "gray2 = 0.2126 * img2[..., 2] + 0.7152 * img2[..., 1] + 0.0722 * img2[..., 0]\n",
    "\n",
    "# [h, w]\n",
    "recs = np.array(((42, 42), (56, 56), (70, 70)), dtype=np.float32)\n",
    "\n",
    "detects = np.ndarray((0, 5), dtype=np.float32)\n",
    "\n",
    "# sliding window\n",
    "for y in range(0, H2, 4):\n",
    "    for x in range(0, W2, 4):\n",
    "        for rec in recs:\n",
    "            dh = int(rec[0] // 2)\n",
    "            dw = int(rec[1] // 2)\n",
    "            x1 = max(x-dw, 0)\n",
    "            x2 = min(x+dw, W2)\n",
    "            y1 = max(y-dh, 0)\n",
    "            y2 = min(y+dh, H2)\n",
    "            region = gray2[max(y-dh,0):min(y+dh,H2), max(x-dw,0):min(x+dw,W2)]\n",
    "            region = resize(region, H_size, H_size)\n",
    "            region_hog = hog(region).ravel()\n",
    "\n",
    "            score = nn.forward(region_hog)\n",
    "            if score >= 0.7:\n",
    "                #cv2.rectangle(img2, (x1, y1), (x2, y2), (0,0,255), 1)\n",
    "                detects = np.vstack((detects, np.array((x1, y1, x2, y2, score))))\n",
    "\n",
    "\n",
    "# Non-maximum suppression\n",
    "def nms(_bboxes, iou_th=0.5, select_num=None, prob_th=None):\n",
    "    #\n",
    "    # Non Maximum Suppression\n",
    "    #\n",
    "    # Argument\n",
    "    #  bboxes(Nx5) ... [bbox-num, 5(leftTopX,leftTopY,w,h, score)]\n",
    "    #  iou_th([float]) ... threshold for iou between bboxes.\n",
    "    #  select_num([int]) ... max number for choice bboxes. If None, this is unvalid.\n",
    "    #  prob_th([float]) ... probability threshold to choice. If None, this is unvalid.\n",
    "    # Return\n",
    "    #  inds ... choced indices for bboxes\n",
    "    #\n",
    "\n",
    "    bboxes = _bboxes.copy()\n",
    "    \n",
    "    bboxes[:, 2] = bboxes[:, 2] - bboxes[:, 0]\n",
    "    bboxes[:, 3] = bboxes[:, 3] - bboxes[:, 1]\n",
    "    print(bboxes[:, 2])\n",
    "    print(bboxes[:, 3])\n",
    "    # Sort by bbox's score. High -> Low\n",
    "    sort_inds = np.argsort(bboxes[:, -1])[::-1]\n",
    "\n",
    "    processed_bbox_ind = []\n",
    "    return_inds = []\n",
    "\n",
    "    unselected_inds = sort_inds.copy()\n",
    "    \n",
    "    while len(unselected_inds) > 0:\n",
    "        process_bboxes = bboxes[unselected_inds]\n",
    "        argmax_score_ind = np.argmax(process_bboxes[::, -1])\n",
    "        max_score_ind = unselected_inds[argmax_score_ind]\n",
    "        return_inds += [max_score_ind]\n",
    "        unselected_inds = np.delete(unselected_inds, argmax_score_ind)\n",
    "\n",
    "        base_bbox = bboxes[max_score_ind]\n",
    "        compare_bboxes = bboxes[unselected_inds]\n",
    "        \n",
    "        base_x1 = base_bbox[0]\n",
    "        base_y1 = base_bbox[1]\n",
    "        base_x2 = base_bbox[2] + base_x1\n",
    "        base_y2 = base_bbox[3] + base_y1\n",
    "        base_w = np.maximum(base_bbox[2], 0)\n",
    "        base_h = np.maximum(base_bbox[3], 0)\n",
    "        base_area = base_w * base_h\n",
    "\n",
    "        # compute iou-area between base bbox and other bboxes\n",
    "        iou_x1 = np.maximum(base_x1, compare_bboxes[:, 0])\n",
    "        iou_y1 = np.maximum(base_y1, compare_bboxes[:, 1])\n",
    "        iou_x2 = np.minimum(base_x2, compare_bboxes[:, 2] + compare_bboxes[:, 0])\n",
    "        iou_y2 = np.minimum(base_y2, compare_bboxes[:, 3] + compare_bboxes[:, 1])\n",
    "        iou_w = np.maximum(iou_x2 - iou_x1, 0)\n",
    "        iou_h = np.maximum(iou_y2 - iou_y1, 0)\n",
    "        iou_area = iou_w * iou_h\n",
    "\n",
    "        compare_w = np.maximum(compare_bboxes[:, 2], 0)\n",
    "        compare_h = np.maximum(compare_bboxes[:, 3], 0)\n",
    "        compare_area = compare_w * compare_h\n",
    "\n",
    "        # bbox's index which iou ratio over threshold is excluded\n",
    "        all_area = compare_area + base_area - iou_area\n",
    "        iou_ratio = np.zeros((len(unselected_inds)))\n",
    "        iou_ratio[all_area < 0.9] = 0.\n",
    "        _ind = all_area >= 0.9\n",
    "        iou_ratio[_ind] = iou_area[_ind] / all_area[_ind]\n",
    "        \n",
    "        unselected_inds = np.delete(unselected_inds, np.where(iou_ratio >= iou_th)[0])\n",
    "\n",
    "    if prob_th is not None:\n",
    "        preds = bboxes[return_inds][:, -1]\n",
    "        return_inds = np.array(return_inds)[np.where(preds >= prob_th)[0]].tolist()\n",
    "        \n",
    "    # pick bbox's index by defined number with higher score\n",
    "    if select_num is not None:\n",
    "        return_inds = return_inds[:select_num]\n",
    "\n",
    "    return return_inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "detects = detects[nms(detects, iou_th=0.25)]\n",
    "detects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for d in detects:\n",
    "    v = list(map(int, d[:4]))\n",
    "    cv2.rectangle(img2, (v[0], v[1]), (v[2], v[3]), (0,0,255), 1)\n",
    "    text = format(d[-1][0], '.1f')\n",
    "    cv2.putText(img2, text, (v[0], v[1]+9),cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255,0,255), 1)\n",
    "plt_img(img2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(1,5,1)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
